* Update UI to v0.2.0

* update ui-tests submodule manually

---------

Co-authored-by: ricopinazo <[email protected]>
Co-authored-by: Pedro Rico Pinazo <[email protected]>

chore: Release

Co-authored-by: Pometry-Team <[email protected]>

chore: Release

Co-authored-by: Pometry-Team <[email protected]>

…2391)

* Added tests for loading edges from polars and from fireducks. Added a load_edges_from_polars that internally calls to_pandas() on the polars dataframe. Fireducks works.

* Adding loading of data (only edges for now) from arrow directly

* Adding loading of data (only edges for now) from arrow with streaming in rust instead of obtaining each column of each batch from Python individually.

* Added loading of edges from DuckDB, either normally or using streaming.

* Added loading edges from fireducks.pandas dataframes. General cleaning up. Committing benchmarks and tests that check graph equality when using different ingestion pathways.

* Adding flag to stream/not stream data in load_* functions. Will get rid of them and always stream. Added benchmark for loading from fireducks.

* Added functions for load_nodes, load_node_props, load_edges, load_edge_props, that all use the __arrow_c_stream__() interface. If a data source is passed with no __len__ function, we calculate the len ourselves. Updated ingestion benchmarks to also test pandas_streaming, fireducks_streaming, polars_streaming

* Cleaned up benchmark print statements

* Ran make stubs

* Removed num_rows from DFView. No longer calculating/storing the total number of rows.

* Cleaned up load_*_from_df functions. load_edge_props/load_node_props renamed to load_edge_metadata/load_node_metadata.

* Re-added total number of rows in DFView, but as an Option. We use it if the data source provides __len__(), and if not, the loading/progress bar for loading nodes and edges doesn't show progression, only iterations per second.

* Added splitting of large chunks into smaller chunks so that the progress bar for loading updates properly when using the __arrow_c_stream__ interface.

* Renamed props to metadata for remaining functions

* Added tests to check equality between graphs created using different ingestion pathways

* Changed load_*_metadata_* back to load_*_props_*

* Fixed tests and updated workflow dependencies

* Added try-catch blocks for fireducks import in tests

* Fixed tests and notebooks

* Fixed invalid function call in test

* Fixed fireducks package not available on Windows (for now anyway)

* Added load_*_from_df functions to PyPersistentGraph, including load_edge_deletions_from_df

* Cleaned up load_from_df tests and parametrized them to run for both event graphs/persistent graphs.

* Fixed bug in tests

* Removed btc dataset benchmarks

* Merge cleanup and fixing python docs errors

* Changed unsafe ArrowArrayStreamReader pointer cast to stream arrow data from python. Replaced it with PyRecordBatchReader::from_arrow_pycapsule for safety and future changes.

* Removed artefact comment

* Fix innit and tidy

* chore: apply tidy-public auto-fixes

---------

Co-authored-by: miratepuffin <[email protected]>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

* Implementing HistoryObject for node and edge objects. Currently, the HistoryObject holds iterators over history items to return them as needed. HistoryObjects can be aggregated in CompositeHistory.

* Updated HistoryObject to now be called HistoryImplemented, and HistoryObject is now a trait. HistoryImplemented holds a node or edge object and retrieves forward and reverse iterators through functions. CompositeHistory now holds a vector of Boxes containing HistoryObjects.

* Updated HistoryImplemented to have merge() and compose() functions. They return MergedHistory and CompositeHistory wrapped in HistoryImplemented objects respectively. MergedHistory holds two InternalHistoryOps objects while CompositeHistory stores a vector of arbitrarily many. MergedHistory is slightly more efficient but if nested with itself, can lose efficiency.

* Updated history object. Began implementing the pyo3 interface. The pyo3 file doesn't compile yet

* Implemented preliminary PyO3 file which currently compiles. We can get an iterator over the history events in the history object. History objects can be created from nodes and edges. We can do list(history_object) in python. Removed Arc constraint on the history object.

* Added PartialEq and Eq to History Objects, which compare their iterators. Attempted to implement __eq__ and __ne__ for python objects. Added timeindex.rs file to raphtory-api module to support the conversion of TimeIndexEntry type into PyRaphtoryTime, accessible in python.

* History object is now fully accessible in python. Merge and composite functions still need to be added

* Added compose_from_histories() function.

* CompositeHistory object now uses Arc instead of Box as its pointers. Started work on python compose_from_items() function, doesn't work yet. Can't retrieve the python objects. Implemented first iteration of graphql file

* Nodes and Edges return the history object when calling history on them in graphql. Implemented hashing both in rust and in python. They can theoretically now be used in hashmaps (maps) in python.

* Implemented tests for History object in graphql using python. Tested directly on nodes and edges, using windows, using layers, and using property filters.

* Renamed TemporalProp to TemporalProperty

* Synced with master and ran rustfmt

* Made TimeIndexEntry available in Python so that they can be created and manipulated. They implement Eq and Ord functionalities, even in python

* Ran rustfmt

* Trying to change NodeOp for History to return the history object rather than a vec<i64>

* Renamed the history operation from History to HistoryOp, the history object is called History. Fixed implementation of NodeOp for HistoryOp.

* Updated the rest of the code to work with new history object being returned as a result of applying HistoryOp

* Implemented InternalHistoryOps for TemporalProperties

* Changed InternalHistoryOps implementation from TemporalProperties to TemporalPropertyView and ran rustfmt

* Fixed some python errors regarding the history object

* Updated TimeSemantics node_earliest_time() and node_latest_time() to return TimeIndexEntry instead of i64. Created new EarliestDateTime struct which implements NodeOp but returns DateTime<Utc> instead of i64, might be removed later. Removed NodeOpFilter from Map for NodeOp

* All tests pass using the history object

* Implemented error type TimeError for errors related to time operations. Currently supports OutOfRange when trying to convert to DateTime<Utc> from an out-of-range i64 and NotFound for operations where a time entry is not found. Changed output type of dt() from an Option to a Result so that these errors can be propagated.

* Changed most TimeErrors for GraphErrors for consistency. Went back to Options for time information which isn't found, now Result<Option<DateTime>, GraphError>. Continued integrating these in the python interface. Errors in macros persist.

* Made TemporalPropertyView Clone. Changed it's history function to return my history object. Changed function temporal_history() of TemporalPropertyViewOps to return TimeIndexEntries instead of i64. Propagated changes

* Fixed python interface for temporal props

* Attempted to fix errors in lazy_node_state macros, doesn't work. We need to handle Results differently. We might need a new Op type that can return errors so they can be handled properly, especially in the macros.

* Implemented Intervals object so that we can work on intervals between timestamps

* Changing datetime functions to return Result<Option, Error> because dt conversion could fail

* reformat using rustfmt

* History Object no longer has errors, implemented iter and iter_rev for node_view and edge_view. iter_rev does not apply TimeSemantics filtering for edge_view yet.

* Changed HistoryOp to return the history object instead of Vec<i64>. HistoryOp on nodes now has a lifetime because NodeView has a lifetime and is contained in the output History Object.

* Added ops::EarliestTime/ops::LatestTime implementations to history object as comments in case we want to use them instead. Fixed tests because they were failing after the refactor

* Changed many time operations (such as history, earliest_time, latest_time, ...) to return TimeIndexEntry for nodes, edges, and temporal props. Propagated these TimeIndexEntries.

* Implemented _rev functions that return iterators over edge histories in reverse, both for edge_history and edge_history_window functions. Updated history object to use these new functions

* Implemented _rev functions that return iterators over node histories in reverse, both for node_history and node_history_window functions. Updated history object to use these new functions

* Created HistoryRef which holds references to items instead of owning them to fix lifetime issues. Fixed many errors in Python module. Propagated TimeIndexEntries in many functions, especially relating to props. Added equality comparison on History object and on TimeIndexEntry==i64.

* Updated intervals to hold an item which yields time entries instead of holding a vector of interval values. The interval values can be calculated lazily.

* Updated intervals to hold a reference to an item which yields time entries instead of owning the item. Updated tests for intervals and for the history object when using a layer.

* Changed EdgeViewOps history() function to return History object instead of a vector of all timestamps

* Added t(), dt(), and s() functions to History object. They return a history object whose iter() and collect() functions yield items of the appropriate type (i64 timestamp, DateTime<Utc>, or secondary index). They all own the InternalHistoryOps object they use (by receiving a clone), same in intervals and merge. That is, except in HistoryRef, where they receive a reference. Added len function to InternalHistoryOps. Clone requirement added throughout History.rs.

* Added history() function to Nodes struct which returns History object. Fixed some History earliest_time and latest_time implementations in aggregate types to call respective inner time functions. CompositeHistory is now generic over lifetimes (namely NodeViews with 'graph lifetime).

* Changed EdgeView time functions to return TimeIndexEntry instead of i64. History object's earliest_time and latest_time can now be done more efficiently by calling the edge's appropriate functions. History objects are now generic over lifetimes

* Implemented history functions directly on LazyNodeState<HistoryOp...>. They map each node to a History object containing it. Wrote test cases for graph.nodes().history(), which returns a history object per node, and for History::new(LazyNodeState<HistoryOp...>), which returns a single history object for all nodes. The latter orders all time entries for the whole set of nodes, while the former only orders time entries within each node.

* Added support for graph.nodes().neighbours().combined_history() and graph.node("some_node").neighbours().combined_history() by implementing InternalHistoryOps for PathFromNode and PathFromGraph.

* Working on macros so that History object can be implemented into python. Created some new types for Python iterables, especially for edges. Started working on macros for node ops as well. Still unfinished.

* Added Nested types on Result iterables types for Python. Fixed all Edges functions in Python. PyGenericIterator and PyNestedGenericIterator have "from_result_iter" and "from_nested_result_iter" constructors to support result types.

* Changed PyEdge and PyNode history() functions to return history object. Added HistoryTimestamp, HistoryDateTime, and HistorySecondary in Python. Fixed PyPathFromGraph iterable return types. Fixed errors

* Added t, dt, s, intervals functions in python. Changed __list__ and collect_rev functions to return NumPy arrays instead of Vec, better for performance. Fixed some history functions in python to return proper history objects.

* Fixed PyBorrowingIterator for Result types. Created new macro and function to create them for iterators that return Result types which need to be converted into python objects

* Removed _date_time functions (earliest_date_time, latest_date_time, history_date_time, ...), as well as history_counts functions. Added support for history.reverse() which reverses iter() and iter_rev() functions. Added combined_history() functions for PathFromGraph and PathFromNode

* Removed histories, histories_rev, histories_date_time from TemporalPropertyView. Changed graph.nodes().start() and end() to return TimeIndexEntry instead of i64. WindowedGraph now holds Option<TimeIndexEntry> instead of Option<i64> as start and end. Changed view_start(), view_end(), shrink_start(), shrink_end(), shrink_window(). Changed internal_window() to take Option<TimeIndexEntry> for window creation. Changed impl_timeops! macro.

* Changed timeline_start and timeline_end to return Option<TimeIndexEntry> instead of Option<i64>. Fixed tests.

* Changed IntoTime to return TimeIndexEntry instead of i64. Added AsTimeInput trait for time inputs. Added saturating_add on TimeIndexEntry which increments the timestamp and leaves secondary index untouched

* Fixed some errors after merge. Changed node_earliest_time_window and node_earliest_time_window to return TimeIndexEntry instead of i64. Removed unused imports

* Changed windowing functions to use TimeIndexEntry instead of i64, especially in the input Range: has_temporal_prop_window, temporal_prop_iter_window, window_bound, is_node_prop_update_available_window, is_node_prop_update_latest_window, is_edge_prop_update_available_window, is_edge_prop_update_latest_window. Removed temporal_history_date_time, items_date_time.

* Moved IntoTime (and associated traits), as well as PyTime to raphtory-api crate. Moved FromPyObject implementation which parses time/date inputs to TimeIndexEntry instead of PyTime. This is now in raphtory-api. PyRaphtoryTime has been replaced by PyTime.

* Updated all function arguments which were previously PyTime to now be TimeIndexEntry because we changed the parsing of input times from PyTime to TimeIndexEntry.

* Current progress in implementing Python versions of LazyNodeState and NodeState for EarliestDateTime NodeOp. Added macro to build py_borrowing_iter where the item is a Tuple containing a result. Manually implementing the python structs so that we can handle the Result types appropriately.

* Implemented Python wrapper for NodeState of Result<Option<DateTime<Utc>>, TimeError> types. Has group_by ops as well as ord ops. Error values and None values are ignored in many functions, such as median and group_by operations.

* Implemented Python wrapper for LazyNodeState of Map<EarliestTime, Result<Option<DateTime<Utc>>, TimeError>> for EarliestTime and LatestTime types. Has group_by ops as well as ord ops. Error values and None values are ignored in many functions, such as median and group_by operations. Still missing layer ops and time ops, we need to implement NodeOpFilter for Map.

* Re-introduced NodeOpFilter for Map so that OneHopFilter operations can be accessed on LazyNodeState<Map<...>>. One hop implemented on EarliestDateTimeView and LatestDateTimeView.

* Implemented Ord and PartialOrd for History objects. Implemented FromPyObject for History<Arc<dyn InternalHistoryOps>>. Implemented OneHopFilter for LazyNodeState<HistoryOp>. Implemented HistoryView, a python wrapper for LazyNodeState<HistoryOp>. Implemented a python wrapper for NodeState<History<NodeView>>. Commented out EarliestDateTimeView, LatestDateTimeView, and HistoryDateTime python wrappers for respective ops. Core raphtory now compiles.

* Removed Ord and PartialOrd implementations for History object, they don't make sense. Updated PyHistory to include more functions.

* Fixed GraphQL errors. Added more functions to GqlHistory available in Rust.

* Added GqlTimeIndexEntry, a GraphQL wrapper for TimeIndexEntry. Time operations now return this wrapper. GqlPropertyTuple operations now use this wrapper as well.

* Changed GqlHistory to return GqlTimeIndexEntry instead of i64 for time related functions. Added GqlHistoryTimestamp, GqlHistoryDateTime, GqlHistorySecondaryIndex, which are wrappers around their respective Rust History objects. They provide access to history information in different formats in GraphQL. GqlHistoryDateTime outputs datetimes as formatted strings. Default formatting is RFC 3339 and allows formatting using custom format strings. Uses chrono::format::strftime for formatting.

* Updates to GraphQL history objects: updated all functions to use blocking_compute(). Added page() and page_rev() functions. Renamed collect() and collect_rev() functions to list() and list_rev().

* Fixed errors after merge

* Fixed tests after merge

* Re-added pometry-storage-private submodule at commit fac0f56

* Activated private storage. Moved some Python logic around, moved some Python specific functionality under python feature.

* Changed t, dt, secondary_index, and history functions to not require brackets () when called in python

* Added support for extracting TimeIndexEntry from [int, int] in Python. Like this, the secondary index can be specified in Python. Removed saturating_add() function on TimeIndexEntry because it might be confusing. next() and previous() on TimeIndexEntry should increment the secondary index, not the timestamp.

* Changed TimeIndexEntry parsing from Python to allow tuples/lists (of size 2) using any combination of types already supported. Allow (int, int), (str, int), (int, str), (date, int), (int, date), and so on...

* Fixed the rust tests, they all pass. Parquet serialization tests only check timestamps, secondary indices are not preserved. Update python add functions (add_node, add_edge, add_updates) to take TimeIndexComponent (i64) instead of TimeIndexEntry.

* Updated stubs. Updated stub_gen and makefile to work with conda environments. Updated add_classes! macro used for Python. Renamed RaphtoryTime in Python to TimeIndexEntry. Added t, dt, secondary_index, intervals functions to HistoryIterable (obtained with g.edges.history). Implemented comparison between TimeIndexEntry and other time types (i64, str, datetime, other TimeIndexEntry, ...)

* Added t, dt, secondary_index, and intervals functions on NestedHistoryIterable (obtained by something like g.nodes.in_edges.history). Re-added histories() on PyTemporalProperties. Fixed From<&PyTemporalProperties> for PyTemporalPropsCmp to use iter_filtered instead of iter. If a property is empty at that time, it won't include an empty list (fixed python comparisons)

* Added __repr__() for different history types (t, dt, secondary_index, intervals). Updated TimeIndexEntry to pass errors through. If a single component fails to convert (from string or float parsing), the appropriate error message now surfaces to python. Furthermore, each time component in a list/tuple has individual error messages surface to help fixing errors.

* Current progress in fixing the python tests

* Added t, dt, secondary_index on python LazyNodeStates (for earliest and latest times) as well as Python TimeIndexEntry iterables. Fixed some errors related to exporting, networkx, and TemporalProperty history. Added __contains__, __eq__, __ne__ for all history objects (History, HistoryTimestamp, ...)

* Fixed all python tests

* Fixed rust-side t, dt, secondary_index, intervals functions on LazyNodeState<HistoryOp>

* Current progress in resolving issues

* Current progress in resolving issues

* Current progress in resolving issues. Added first() and last() on history objects. Changed median() on intervals to return i64 instead of f64. Removed display() on GqlTimeIndexEntry.

* Added DeletionHistory to History. edge1.deletions() now returns a History<DeletionHistory<EdgeView>> object. Added reverse iterators for edge_deletion_history. Fixed tests.

* Added rust-side t, dt, and secondary_index functions for LazyNodeState<EarliestTime> and <LatestTime>. Added python-side t, dt, secondary_index, intervals, earliest_time, latest_time for LazyNodeState<HistoryOp> and NodeState<History>. They map the Op for LazyNodeState and change computed values for NodeState. Implemented all the different return types in Python (eg. LazyNodeState<ops::Map<HistoryOp, PyHistoryTimestamp>> for all LazyNodeState and NodeState of each History/Interval object. Added collect_valid and iter_valid on LazyNodeState<EarliestDateTime> and <LatestDateTime> which return only valid values (no errors or None)

* Fixed different Time traits in general. Moved FromPyObject for time inputs from TimeIndexEntry to InputTime, which can differentiate between single inputs (timestamp only) and two inputs (secondary index as well).

* Current progress in resolving issues. sorted() and groups() now pull the errors out of the NodeState so that the NodeState doesn't contain any error values. Added values_valid, items_valid, and iter_valid on LazyNodeState<Result<DateTime>> and NodeState<Result<DateTime>> that only return valid values (no errors or None values).

* Added IntoArcDynHistoryOps to define how an InternalHistoryOps object gets wrapped into an Arc<dyn InternalHistoryOps>. Downcasting is no longer used in From<History> for PyHistory to avoid nesting Arcs infinitely.

* Changed WindowTimeSemantics to use a Range<TimeIndexEntry> instead of Range<i64> for it's window. Changed all NodeTimeSemanticsOps and EdgeTimeSemanticsOps to use Range<TimeIndexEntry> as well to reflect this change.

* Got rid of NodeState<Result<Option<DateTime>>>. Any functions that used to return it now return Result<NodeState<Option<DateTime>>>. The function itself might fail but the NodeState will not contain any errors. Changed earliest_time_window and latest_time_window to take TimeIndexEntry instead of i64. Fixed flatten() on LazyNodeState<HistoryOp> and added it on NodeState<History>.

* Changed CompositeHistory to hold Box<[Box<dyn InternalHistoryOps + 'a>]> instead of Vec<Arc<dyn InternalHistoryOps + 'a>>.

* Removed date_time on edge/edges and changed time to return TimeIndexEntry. Added secondary indices to to_networkx() and fixed tests. Added TimeIndexEntryIterable and NestedTimeIndexEntryIterable for edges. Added as_tuple function on TimeIndexEntry.

* Updated GraphQL time-based functions and Windows to take GqlTimeInput (i64, string, or tuple (i64||string, usize) instead of only i64. String is a formatted DateTime string. Changed CompositeHistory to hold Box<[T]>. Updated at(), after(), and before() to ignore secondary index of TimeIndexEntry for the time being.

* Renamed Window in vectorised_graph.rs to VectorisedGraphWindow to avoid name clashing with other Window in GraphQL. Updated tests to use new time input semantics

* Current progress in fixing the docstrings.

* Finished fixing the docstrings.

* Ran tidy-public

* Regenerated python stubs and graphql schema after merge.

* Fixed "Option" -> "Optional" typo in Python docs

* Removed unused imports, added some GraphQL docs, added some some classes to base_modules.rs for proper type hints.

* Fixed doc tests and storage tests.

* Added python classes to module and fixed iterable return types.

* Fixed some tests. Removed Iterable types from added Python classes, they will be added later.

* chore: apply tidy-public auto-fixes

* Updated some error messages in raphtory-benchmark

* Fixed benchmark

* Fixed merge issues. Added python tests for history object.

* Added tests for checking TimeIndexEntry/InputTime sting parsing, equality, greater than/less than comparisons, tuple behaviour, ...

* chore: apply tidy-public auto-fixes

* Removed histories_timestamps(). Added GraphQL tests for datetimes, formatting using string, secondary index, simple and indexed time input parsing, window borders for indexed time input.

* chore: apply tidy-public auto-fixes

* Allowed history objects to be compared with lists in python. The list can contain anything that can be parsed to a TimeIndexEntry, indexed or not.

* Fixed GraphQL server crashing when invalid format string is passed to datetime function. Updated GqlTimeInput parsing to be simpler. Now, a number, string, or Object {epoch, index} can directly be passed without specifying fields (except for epoch/index to specify index).

* Fixed merge issues

* Fixed failing rust tests

* Fixed failing rust storage tests except for one

* Renaming TimeIndexEntry to EventTime. Updating all documentation, API function names, and associated types (like iterables) to match. EventTime contains a Unix Epoch timestamp and an event_id (previously secondary_index).

* Still renaming TimeIndexEntry to EventTime. Updating all documentation, API function names, and associated types (like iterables) to match.

* Renaming secondary_index from old TimeIndexEntry terminology to event_id.

* Replacing secondary_index terminology from old TimeIndexEntry to event_id in src/search

* Replacing secondary_index terminology from old TimeIndexEntry to event_id for new EventTime.

* Fixed issues

* docs fixes

* update object name to EventTime

* Changed many unnecessary try_into_time() function calls with into_time(). Updated some at() functions to take EventTime/GqlTimeInput instead of i64.

* Fixing tests

* Moved impl blocks for EventTime iterables to a separate file, so custom function definitions aren't alongside macro uses.

* chore: apply tidy-public auto-fixes

* Reverted previous changes made to Makefile

* Cleaned up custom node_state files

* Renamed epoch to timestamp for EventTime

* Fixed tests

* rust format and general merge fixes

* chore: apply tidy-public auto-fixes

* moved history tests to tests folder

* cleaned up docs

* chore: apply tidy-public auto-fixes

* removed changes previously made to stub_gen for debugging purposes

* Added intervals functions such as mean, median, min, max on LazyNodeState<Interval> and NodeState<Interval>. Updated docs. Added to_list() -> list[int] alternatives for all collect() -> np.NDArray[np.int64] functions (PyHistoryTimestamp, PyHistoryEventId, PyIntervals, ...). Reorganized node_state.rs file to remove custom function implements and move them to their own files (node_state_earliest_time.rs, node_state_history.rs, ...). Added NodeState<Option<f64>>. Added a test for LazyNodeState and NodeState of Intervals.

* Fixed issues after merge

* Fixed tests after merge

* chore: apply tidy-public auto-fixes

* Fixed tests after merge

* Updated stubs

* Fixed storage feature imports

* Fixed failing tests and updated earliest_edge_time and latest_edge_time to return EventTime instead of i64

* chore: apply tidy-public auto-fixes

* Fixed failing test

* chore: apply tidy-public auto-fixes

* chore: apply tidy-public auto-fixes

* chore: apply tidy-public auto-fixes

* Adding PyOptionalEventTime, a python wrapper for Option<EventTime> so that functions that return Option<EventTime> don't crash in python when we get None and call .t(), .dt(), ...

* Changing python functions that return Option<EventTime> to return PyOptionalEventTime instead. Calling .t(), .dt(), ... on this object will not raise an exception in python even if the option is None.

* PyOptionalEventTime: added repr() and added it to add_classes!

* Added comparison functions for PyOptionalEventTime. They can be compared with EventTime as normal.

* General fixes and clean up after merge

* Added comparison to PyEventTime for PyOptionalEventTime. Added tests for comparison. Fixed python docs return type annotations.

* Added __getitem__ on history objects to allow subscript notation: history[index]. Added EventTime and OptionalEventTime as TimeInput types. Fixed tests

* Added a GqlOptionalEventTime type so that if a function returns None, we can still call timestamp, datetime, etc... on it without panicking.

* Changed GqlEventTime to hold an Option<EventTime> and got rid of GqlOptionalEventTime. Replaced all uses with this updated type.

* Fixed GraphQL tests

* Added support for ingesting `date` types from python, previously it was just `datetime` types. This is supported anywhere that an EventTime or an InputTime is expected.

* Added IntoIterator for History<T> wrapper objects when T: 'static. Added flatten and flattened_list function for all iterable and nested iterable types of history objects (History, HistoryTimestamp, HistoryDatetime, ...). Added tests for python datetime.date ingestion

* Fixes after merge

* Fixed tests

* chore: apply tidy-public auto-fixes

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
Co-authored-by: James Baross <[email protected]>
Co-authored-by: Ben Steer <[email protected]>

* only trigger autofixing if all tests pass

* disable UI-test dependency as they are currently broken so that the autofix actually runs

* make sure graphql schema is actually updated and improve compile time in format workflow

* install all dependencies for the stubs-gen

* create a venv to avoid problems with maturin

* disable needs to speed up testing the workflow

* don't install raphtory twice

* need to activate the venv

* new attempt at getting the fast install to work properly

* reenable needs checks

* chore: apply tidy-public auto-fixes

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

* Made sssp directed

* chore: apply tidy-public auto-fixes

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

* register plugins in stable order to avoid churn in the docs

* clean up warnings

* local clustering coefficient relax static graph requirement

* chore: apply tidy-public auto-fixes

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

* Update UI to v0.2.1

* chore: apply tidy-public auto-fixes

* Update action to install all deps

---------

Co-authored-by: louisch <[email protected]>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
Co-authored-by: Louis Chan <[email protected]>